import request from '../utils/request'
import taskService from './taskService.js'

/**
 * 全流程投演服务 - 提供阶段管理、任务分配等功能
 */

// 模拟存储 - 在实际项目中会由后端数据库替代
let mockStagesData = [
  {
    id: '1',
    name: '准备阶段',
    order: 1,
    selectedTasks: ['变量审核']
  },
  {
    id: '2',
    name: '第一轮测试',
    order: 2,
    selectedTasks: ['第一轮演练']
  },
  {
    id: '3',
    name: '第二轮测试',
    order: 3,
    selectedTasks: ['第二轮演练']
  },
  {
    id: '4',
    name: '投产前准备',
    order: 4,
    selectedTasks: ['投产前演练']
  }
]

/**
 * 获取投演阶段列表
 * @returns {Promise} 阶段列表数据
 */
export const getSimulationStages = async () => {
  try {
    // 模拟API调用，实际项目中应替换为真实接口
    // const response = await request.get('/api/simulation/stages')
    // return response.data
    
    return new Promise((resolve) => {
      setTimeout(() => {
        // 返回排序后的模拟数据
        resolve({
          data: [...mockStagesData].sort((a, b) => a.order - b.order)
        })
      }, 300)
    })
  } catch (error) {
    console.error('获取投演阶段失败:', error)
    throw error
  }
}

/**
 * 创建新的投演阶段
 * @param {Object} stageData - 阶段数据
 * @param {string} stageData.name - 阶段名称
 * @param {Array} stageData.selectedTasks - 选中的任务列表
 * @returns {Promise} 创建结果
 */
export const createSimulationStage = async (stageData) => {
  try {
    // 模拟API调用，实际项目中应替换为真实接口
    // const response = await request.post('/api/simulation/stages', stageData)
    // return response.data
    
    // 模拟创建操作
    return new Promise((resolve) => {
      setTimeout(() => {
        // 模拟生成ID和设置顺序（实际应由后端处理）
        const newStage = {
          id: Date.now().toString(),
          name: stageData.name,
          order: stageData.order,
          selectedTasks: stageData.selectedTasks || []
        }
        resolve({ data: newStage })
      }, 300)
    })
  } catch (error) {
    console.error('创建投演阶段失败:', error)
    throw error
  }
}

/**
 * 更新投演阶段
 * @param {string} id - 阶段ID
 * @param {Object} stageData - 更新的阶段数据
 * @returns {Promise} 更新结果
 */
export const updateSimulationStage = async (id, stageData) => {
  try {
    // 模拟API调用，实际项目中应替换为真实接口
    // const response = await request.put(`/api/simulation/stages/${id}`, stageData)
    // return response.data
    
    return new Promise((resolve) => {
      setTimeout(() => {
        // 在模拟存储中更新阶段数据
        const stageIndex = mockStagesData.findIndex(stage => stage.id === id)
        if (stageIndex !== -1) {
          mockStagesData[stageIndex] = { ...mockStagesData[stageIndex], ...stageData }
        }
        resolve({ data: { id, ...stageData } })
      }, 300)
    })
  } catch (error) {
    console.error('更新投演阶段失败:', error)
    throw error
  }
}

/**
 * 删除投演阶段
 * @param {string} id - 阶段ID
 * @returns {Promise} 删除结果
 */
export const deleteSimulationStage = async (id) => {
  try {
    // 模拟API调用，实际项目中应替换为真实接口
    // const response = await request.delete(`/api/simulation/stages/${id}`)
    // return response.data
    
    // 模拟删除操作
    return new Promise((resolve) => {
      setTimeout(() => {
        resolve({ data: { success: true, id } })
      }, 300)
    })
  } catch (error) {
    console.error('删除投演阶段失败:', error)
    throw error
  }
}

/**
 * 移动投演阶段顺序
 * @param {string} id - 阶段ID
 * @param {number} newOrder - 新的顺序
 * @returns {Promise} 移动结果
 */
export const moveSimulationStage = async (id, newOrder) => {
  try {
    // 模拟API调用，实际项目中应替换为真实接口
    // const response = await request.put(`/api/simulation/stages/${id}/move`, { newOrder })
    // return response.data
    
    // 模拟移动操作
    return new Promise((resolve) => {
      setTimeout(() => {
        resolve({ data: { id, order: newOrder, success: true } })
      }, 300)
    })
  } catch (error) {
    console.error('移动投演阶段失败:', error)
    throw error
  }
}

/**
 * 获取可选的任务类型
 * @returns {Array} 任务类型列表
 */
/**
 * 获取可选任务类型
 * @returns {Promise} 任务类型列表
 */
export const getAvailableTaskTypes = async () => {
  try {
    // 从后端获取任务类型列表
    const response = await taskService.getTaskTypes()
    // 假设返回的响应结构是 { data: [...] }
    return response.data || []
  } catch (error) {
    console.error('获取任务类型失败:', error)
    // 如果失败，返回空数组
    return []
  }
}

/**
 * 获取投产情况汇总数据
 * @returns {Promise} 汇总数据
 */
export const getProductionSummary = async () => {
  try {
    // 模拟API调用，实际项目中应替换为真实接口
    // const response = await request.get('/api/simulation/production-summary')
    // return response.data
    
    // 模拟汇总数据
    return new Promise((resolve) => {
      setTimeout(() => {
        resolve({
          data: {
            totalStages: 4,
            completedStages: 2,
            pendingStages: 2,
            successRate: 85,
            startTime: '2023-07-01 09:00:00',
            estimatedEndTime: '2023-07-15 18:00:00',
            currentStage: '第二轮测试',
            issues: [
              {
                id: '1',
                stage: '准备阶段',
                description: '变量配置错误',
                status: '已解决'
              },
              {
                id: '2',
                stage: '第一轮测试',
                description: '数据同步延迟',
                status: '处理中'
              }
            ]
          }
        })
      }, 300)
    })
  } catch (error) {
    console.error('获取投产情况汇总失败:', error)
    throw error
  }
}